//字符串工具类https://blog.csdn.net/linbilin_/article/details/73506014
StringUtils = {
    /**
     * 判定字符串为空
     * @param str
     * @returns {boolean}
     */
    isEmpty: function(input) {
        return input === undefined || input === null || (typeof input === 'string' && input.trim().length === 0);
    },  
    isNotEmpty: function(input) {  
        return !this.isEmpty(input);  
    },
    trim: function(input) {  
        return input.replace(/^\s+|\s+$/, '');  
    },  
    trimToEmpty: function(input) {  
        return input == null ? "" : this.trim(input);  
    },  
    startsWith: function(input, prefix) {  
        return input.indexOf(prefix) === 0;  
    },  
    endsWith: function(input, suffix) {  
        return input.lastIndexOf(suffix) === 0;  
    },  
    contains: function(input, searchSeq) {  
        return input.indexOf(searchSeq) >= 0;  
    },  
    equals: function(input1, input2) {  
        return input1 == input2;
    },  
    equalsIgnoreCase: function(input1, input2) {  
        return input1.toLocaleLowerCase() == input2.toLocaleLowerCase();  
    },  
    containsWhitespace: function(input) {  
        return this.contains(input, ' ');  
    },  
    //生成指定个数的字符  
    repeat: function(ch, repeatTimes) {  
        var result = "";  
        for(var i = 0; i < repeatTimes; i++) {  
            result += ch;  
        }  
        return result;  
    },  
    //字符分割
    split: function(input,seperator){
        var strs = new Array(); //定义一数组
        strs = input.split(seperator);
        return strs;
    },
    //按换行符分割
    splitLine: function(input){
        var strs = new Array(); //定义一数组
        strs = input.split(/[\n]/);
        return strs;
    },
    //只包含字母  
    isAlpha: function(input) {  
        return /^[a-z]+$/i.test(input);  
    },  
    //只包含字母、空格  
    isAlphaSpace: function(input) {  
        return /^[a-z\s]*$/i.test(input);  
    },  
    //只包含字母、数字  
    isAlphanumeric: function(input) {  
        return /^[a-z0-9]+$/i.test(input);  
    },  
    //只包含字母、数字和空格  
    isAlphanumericSpace: function(input) {  
        return /^[a-z0-9\s]*$/i.test(input);  
    },  
    //数字  
    isNumeric: function(input) {  
        return /^(?:[1-9]\d*|0)(?:\.\d+)?$/.test(input);  
    },  
    //小数  
    isDecimal: function(input) {  
        return /^[-+]?(?:0|[1-9]\d*)\.\d+$/.test(input);  
    },  
    //负小数  
    isNegativeDecimal: function(input) {  
        return /^\-?(?:0|[1-9]\d*)\.\d+$/.test(input);  
    },  
    //正小数  
    isPositiveDecimal: function(input) {  
        return /^\+?(?:0|[1-9]\d*)\.\d+$/.test(input);  
    },  
    //整数  
    isInteger: function(input) {  
        return /^[-+]?(?:0|[1-9]\d*)$/.test(input);  
    },  
    //正整数  
    isPositiveInteger: function(input) {  
        return /^\+?(?:0|[1-9]\d*)$/.test(input);  
    },  
    //负整数  
    isNegativeInteger: function(input) {  
        return /^\-?(?:0|[1-9]\d*)$/.test(input);  
    },  
    //只包含数字和空格  
    isNumericSpace: function(input) {  
        return /^[\d\s]*$/.test(input);  
    },  
    isWhitespace: function(input) {  
        return /^\s*$/.test(input);  
    },  
    isAllLowerCase: function(input) {  
        return /^[a-z]+$/.test(input);  
    },  
    isAllUpperCase: function(input) {  
        return /^[A-Z]+$/.test(input);  
    },  
    defaultString: function(input, defaultStr) {  
        return input == null ? defaultStr : input;  
    },  
    defaultIfBlank: function(input, defaultStr) {  
        return this.isBlank(input) ? defaultStr : input;  
    },  
    defaultIfEmpty: function(input, defaultStr) {  
        return this.isEmpty(input) ? defaultStr : input;  
    },  
    //字符串反转  
    reverse: function(input) {  
        if(this.isBlank(input)) {  
            input;  
        }  
        return input.split("").reverse().join("");  
    },  
    //中文校验  
    isChinese: function(input) {  
        return /^[\u4E00-\u9FA5]+$/.test(input);  
    },  
    //去掉中文字符  
    removeChinese: function(input) {  
        return input.replace(/[\u4E00-\u9FA5]+/gm, "");  
    }
};  

ArrayUtils = {
    //根据prop 属性进行排序
    sort: function (arr,prop) {
        return arr.sort(compare(prop));
    },

    //数组元素翻转
    reverse:function(arr) {
        return arr.reverse();
    },
    
    //查找所有prop=value 的对象
    find:function(arr,prop,value){
        //返回数组，包含了符合条件的所有元素。如果没有符合条件的元素则返回空数组。
        return arr.filter(item => item[prop] === value);
    },

    //查找所有prop like %value% 的对象
    findLike:function(arr,prop,value){
        //返回数组，包含了符合条件的所有元素。如果没有符合条件的元素则返回空数组。
        return arr.filter(item => containsLike(item[prop],value));
    },

    //移除所有prop=value 的对象
    remove:function(arr,prop,value){
        return arr.filter(item => !(item[prop] === value));
    },

    //移除所有prop like %value% 的对象
    removeLike:function(arr,prop,value){
        return arr.filter(item => !containsLike(item[prop],value));
    },

    contains:function(input, likeString) {  
        return input.indexOf(likeString) >= 0;  
    },

    containsLike:function (input, likeString) {  
        return input.toUpperCase().indexOf(likeStringtoUpperCase()) >= 0;  
    },

    //数组对象排序 https://www.cnblogs.com/xljzlw/p/3694861.html
    //js中用方法sort()为数组排序。sort()方法有一个可选参数，是用来确定元素顺序的函数。如果这个参数被省略，那么数组中的元素将按照ASCII字符顺序进行排序
    //eg: var arr = [{name: "zlw", age: 24}, {name: "wlz", age: 25}];
    //eg: arr.sort(compare("age"))
    compare:function (prop) {
        return function (obj1, obj2) {
            var val1 = obj1[prop];
            var val2 = obj2[prop];
            if (val1 < val2) {
                return -1;
            } else if (val1 > val2) {
                return 1;
            } else {
                return 0;
            }            
        } 
    }
}


// js封装map https://blog.csdn.net/u011068702/article/details/49512415
// Map map=new Map();  
// map.put("a",“student”);  
// var value=map.get("a");  
// console.log(value);  
function Map(){
    this.elements = new Array();

    /**
     * 返回数组长度
     * @returns {Number}
     */
    this.size = function(){
        return this.elements.length;
    }

    /**
     * 清空数组
     */
    this.clear = function(){
        this.elements = new Array();
    }

    /**
     * 装入数据 {key:value}
     * @param key
     * @param value
     */
    this.put = function(key,value){
        if (key == null || key == undefined)return;
        if(this.containsKey(key)){
            this.update(key,value);
        }else{
            this.elements.push({
                key : key,
                value : value
            })
        }

    }

    /**
     * 根据key获取当前数组中所对应的值 / 找不到返回null
     * @param key
     * @returns {*}
     */
    this.get = function(key){
        try{
            for(var i=0; i<this.size(); i++){
                if(this.elements[i].key == key){
                    return this.elements[i].value;
                }
            }
        }catch(e){
            return null;
        }
        return null;
    }

    /**
     * 根据key删除数组数据
     * @param key
     * @returns {boolean}
     */
    this.remove = function(key){
        try {
            for (var i=0; i< this.size(); i++) {
                if (this.elements[i].key == key){
                    this.elements.splice(i, 1);
                    return true;
                }
            }
        }catch(e){
            return false;
        }
        return true;
    }

    /**
     * 更新数组value值
     * @param key
     * @param value
     * @returns {boolean}
     */
    this.update = function(key,value){
        for(var i=0;i<this.size();i++){
            if(this.elements[i].key == key){
                this.elements[i].value = value;
                return true;
            }
        }
        return false;
    }

    /**
     * 是否包含key值
     * @param key
     * @returns {boolean}
     */
    this.containsKey = function(key){
        try{
            for(var i=0;i<this.size();i++){
                if(this.elements[i].key == key){
                    return true;
                }
            }
        }catch(e){
            return false;
        }
        return false;
    }

    /**
     * 获取数组中所有数据
     * @returns {Array}
     */
    this.keys = function(){
        var array = new Array();
        for(var i=0;i<this.size();i++){
            array.push(this.elements[i].value);
        }
        return array;
    }

    /**
     * 通过数组下标获取data
     * @param number
     * @returns {*}
     */
    this.getIndex = function(number){
        if(number<0 || number>=this.size()){
            return null;
        }
        return this.elements[number];
    }
}


/**
 * 获取 URL 参数
 * @param {*} variable 
 */
function getQueryVariable(variable){
       var query = window.location.search.substring(1);
       var vars = query.split("&");
       for (var i=0;i<vars.length;i++) {
               var pair = vars[i].split("=");
               if(pair[0] == variable){return pair[1];}
       }
       return(false);
}

/**
 * 封装GET请求参数
 * @param url 基础URl
 * @param params {}对象型数据
 * @returns
 */
function toUrl(url, params){
    var paramsArr = [];
    if (params) {
     	for ( var item in params){
     		var value = params[item];
        	if(value===false || value===0 || value){
        		paramsArr.push(item + '=' + value);
        	}
   		}
        if (url.search(/\?/) === -1) {
            url += '?' + paramsArr.join('&');
        } else {
            url += '&' + paramsArr.join('&');
        }

    }
    return encodeURI(url);
}

function setCookie(name,value){
	var Days = 30;
	var exp = new Date();
	exp.setTime(exp.getTime() + Days*24*60*60*1000);
	document.cookie = name + "="+ escape (value) + ";expires=" + exp.toGMTString();
}

function getCookie(name){
	var arr,reg=new RegExp("(^| )"+name+"=([^;]*)(;|$)");
	if(arr=document.cookie.match(reg))
	return unescape(arr[2]);
	else
	return null;
}

//删除cookies 
function delCookie(name) {
	var exp = new Date();
	exp.setTime(exp.getTime() - 1);
	var cval = getCookie(name);
	if (cval != null) document.cookie = name + "=" + cval + ";expires=" + exp.toGMTString();
}

